package com.ruoyi.system.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.PageUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.system.domain.vo.productType.ProductTypeListVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.system.mapper.ProductTypeMapper;
import com.ruoyi.system.domain.ProductType;
import com.ruoyi.system.service.IProductTypeService;
import org.springframework.util.CollectionUtils;

/**
 * 产品类型Service业务层处理
 *
 * @author ruoyi
 * @date 2023-01-25
 */
@Service
public class ProductTypeServiceImpl extends ServiceImpl<ProductTypeMapper, ProductType> implements IProductTypeService
{
    @Autowired
    private ProductTypeMapper productTypeMapper;

    /**
     * 查询产品类型
     *
     * @param id 产品类型主键
     * @return 产品类型
     */
    @Override
    public ProductType selectProductTypeById(Long id)
    {
        return productTypeMapper.selectProductTypeById(id);
    }

    /**
     * 查询一级产品类型列表
     */
    @Override
    public List<ProductType> firstLevelList(ProductType productType) {
        QueryWrapper<ProductType> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(ProductType::getParentId,-1)
                .eq(ProductType::getStatus,0);
        return productTypeMapper.selectList(queryWrapper);
    }

    /**
     * 查询多级产品类型列表
     *
     * @param productType 产品类型
     * @return 产品类型
     */
    @Override
    public List<ProductTypeListVo> selectMultiProductTypeList(ProductType productType)
    {
        QueryWrapper<ProductType> queryWrapper;
        //二级类型列表转map
        Map<Long,List<ProductType>> childMap = new HashMap<>();

        queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().ne(ProductType::getParentId,-1)
                .eq(ProductType::getStatus,0)
                .like(StringUtils.isNotEmpty(productType.getName()),ProductType::getName,"%" + productType.getName() + "%")
                .eq(productType.getParentId() != null,ProductType::getParentId,productType.getParentId())
                .eq(productType.getStatus() != null,ProductType::getStatus,productType.getStatus());
        List<ProductType> childList = productTypeMapper.selectList(queryWrapper);

        childList.forEach((child)->{
            if( childMap.containsKey(child.getParentId()) ){
                List<ProductType> productTypes = childMap.get(child.getParentId());
                productTypes.add(child);
            }else {
                List<ProductType> list = new ArrayList<>();
                list.add(child);
                childMap.put(child.getParentId(),list);
            }
        });

        //一级列表，封装
        List<ProductTypeListVo> voList = new ArrayList<>();
        PageUtils.startPage();
        queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(ProductType::getParentId,-1)
                .eq(ProductType::getStatus,0)
                .like(StringUtils.isNotEmpty(productType.getName()),ProductType::getName,"%" + productType.getName() + "%")
                .eq(productType.getParentId() != null,ProductType::getParentId,productType.getParentId())
                .eq(productType.getStatus() != null,ProductType::getStatus,productType.getStatus());

        List<ProductType> parentList = productTypeMapper.selectList(queryWrapper);

        if(CollectionUtils.isEmpty(parentList)){
            return childList.stream().map((child) -> {
                ProductTypeListVo listVo = new ProductTypeListVo();
                BeanUtils.copyProperties(child, listVo);
                return listVo;
            }).collect(Collectors.toList());
        }

        parentList.stream().forEach((parent)->{
            ProductTypeListVo listVo = new ProductTypeListVo();
            BeanUtils.copyProperties(parent, listVo);
            List<ProductType> productTypeList = childMap.get(parent.getId());
            listVo.setChildren(productTypeList);
            voList.add(listVo);
        });
        return voList;
    }

    /**
     * 查询产品类型列表
     *
     * @param productType 产品类型
     * @return 产品类型
     */
    @Override
    public List<ProductType> selectProductTypeList(ProductType productType)
    {
        return productTypeMapper.selectProductTypeList(productType);
    }

    /**
     * 查询产品类型列表,by ids
     *
     * @param ids
     * @return 产品类型列表
     */
    @Override
    public List<ProductType> selectTypeListByIds(List<Long> ids)
    {
        return productTypeMapper.selectBatchIds(ids);
    }


    /**
     * 查询产品类型Map
     *
     * @param productType 产品类型
     * @return 产品类型
     */
    @Override
    public Map<Long, ProductType> selectProductTypeMap(ProductType productType)
    {
        List<ProductType> productTypes = this.selectProductTypeList(productType);
        Map<Long, ProductType> map = productTypes.stream().collect(Collectors.toMap(ProductType::getId, Function.identity()));
        return map;
    }

    /**
     * 查询一级产品类型Map
     *
     * @param productType 产品类型
     * @return 产品类型
     */
    @Override
    public Map<Long, String> selectSuperProductTypeMap(ProductType productType)
    {
        List<ProductType> productTypes = this.firstLevelList(productType);
        Map<Long, String> map = productTypes.stream()
                .collect(Collectors.toMap(ProductType::getId, ProductType::getName));
        return map;
    }

    /**
     * 新增产品类型
     *
     * @param productType 产品类型
     * @return 结果
     */
    @Override
    public int insertProductType(ProductType productType)
    {
        productType.setCreateTime(DateUtils.getNowDate());
        return productTypeMapper.insertProductType(productType);
    }

    /**
     * 修改产品类型
     *
     * @param productType 产品类型
     * @return 结果
     */
    @Override
    public int updateProductType(ProductType productType)
    {
        productType.setUpdateTime(DateUtils.getNowDate());
        return productTypeMapper.updateProductType(productType);
    }

    /**
     * 批量删除产品类型
     *
     * @param ids 需要删除的产品类型主键
     * @return 结果
     */
    @Override
    public int deleteProductTypeByIds(Long[] ids)
    {
        return productTypeMapper.deleteProductTypeByIds(ids);
    }

    /**
     * 删除产品类型信息
     *
     * @param id 产品类型主键
     * @return 结果
     */
    @Override
    public int deleteProductTypeById(Long id)
    {
        return productTypeMapper.deleteProductTypeById(id);
    }
}
